The Recursive Record Semantics of Objects Revisited

In a call-by-value language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the reconstruction of a principal type. We illustrate the expressive power of this language with respect to object-oriented programming by introducing a sub-language for «mixin-based» programming

Safe Recursive Boxes

We study recursion in call-by-value functional languages, and more specifically a recursion construct recently introduced by Dreyer, which builds recursive boxed values. We design a type and effect system, featuring binary effects, for a call-by-value lambda-calculus extended with this recursion construct. We show that this system has the good properties required for an implicitly, statically typed language: the typable expressions do not yield run-time errors, and a principal type can be computed for any typable expression

Relaxed memory models: an operational approach

International audienceMemory models define an interface between programs written in some language and their implementation, determining which behaviour the memory (and thus a program) is allowed to have in a given model. A minimal guarantee memory models should provide to the programmer is that well-synchronized, that is, data-race free code has a standard semantics. Traditionally, memory models are defined axiomatically, setting constraints on the order in which memory operations are allowed to occur, and the programming language semantics is implicit as determining some of these constraints. In this work we propose a new approach to formalizing a memory model in which the model itself is part of a weak operational semantics for a (possibly concurrent) programming language. We formalize in this way a model that allows write operations to the store to be buffered. This enables us to derive the ordering constraints from the weak semantics of programs, and to prove, at the programming language level, that the weak semantics implements the usual interleaving semantics for data-race free programs, hence in particular that it implements the usual semantics for sequential code

Lambda-calculi for (strict) parallel functions

Résumé disponible sur le PD

Computational semantics of terms rewriting systems

Résumé disponible sur le PD

Towards a lambda-calculus for concurrent and communicating systems

We introduce a calculus for concurrent and communicating processes, which is a direct and simple extension of the lambda-calculus. The communication mechanism we use is that of Milner's calculus CCS: to communicate consists in synchronously sending and receiving a value through a shared port. Then the calculus is parameterized on a given set of port names, which are used in the two primitives for sending and receiving a value -as in the lambda-calculus, a value can be any term. We use two parallel constructs: the first is interleaving, which does not allow communication between agents. The second, called cooperation, is a synchronizing construct which forces two agents to communicate on every port name. We show that the lambda-calculus is a simple sub-calculus of ours: lambda-abstraction is a particular case of reception (on a port named lambda), and application is a particular case of cooperation

Notes on algebraic calculi of processes

Résumé disponible sur le PD

Analyse des langages et modèles de la mobilité

Ce document présente une analyse comparative de divers langages prototypes et modèles formels existants pour la mobilité de code. Trois aspects sont retenus pour cette étude: la distribution, la mobilité, et la sécurité. L'étude est également structurée autour de la notion de domaine qui nous semble centrale dans ces langages et modèles, et illustre différentes sémantiques de cette notion

A lambda-calculus for parallel functions

We study a l-calculus enriched with a non-deterministic choice combinator. We show that this combinator is adequately interpreted as the join in a canonical lattice of (parallel) continuous functions. The canonical model is in fact a logical one, concretely presented in a "typing system". Having established the complteness of this system, we show that the canonical interpretation provides us with a fully abstract model of the l-calculus with join. The proof of completeness relies upon the definability of the finite points of the logical domain

The chemical abstract machine

Weintroducea new kind of abstract machine based on the chemical metaphor used in the G language of Banatre & al. States of a machine are chemical solutions where floating molecules can interact according to reaction rules. Solutions can be stratified by encapsulating subsolutions within membranes that force reactions to occur locally. We illustrate the use of this model by describing the operational semantics of the TCCS and CCS process calculi. We also show how to extract a higher-order concurrent l-calculus out of the basic concepts of the chemical machine